2.1–2.2 Loops

Running the same code, again and again

A loop runs the same block of code repeatedly. Python gives you two kinds: for loops and while loops. Loops pair especially well with strings, since a string can be any length, and a loop doesn't care how many times it has to run. Together, loops and strings let you solve far more interesting problems than one-shot, straight-line code ever could.

Looping a known number of times

A for loop is the tool for when you already know how many passes you need, or you know exactly what you're looping over. Python's range is the most common thing to loop over.

Swap in range(n) instead

def sumToN(n):
    total = 0
    for x in range(n):
        total += x
    return total

With this change, what does sumToN(4) return?

• A 10, exactly the same
• B 6, since it would miss the 4
• C It would crash
• D 0

This factorial is broken

factorial(n) should multiply the integers from 1 to n. This version copies sumToN and swaps += for *=. Predict the output, then run it.

def factorial(n):
    total = 0
    for x in range(n+1):
        total *= x
    return total

print(factorial(4))

Anything times zero is zero

range(n+1) starting at the default 0 includes 0 itself. That was fine for sumToN, adding 0 changes nothing, but for a product, multiplying by 0 even once wipes out the whole running total. The fix: start the range at 1 instead of 0, and start total at 1 too, since it's the identity value for multiplication.

Which block produces this output?

Which block produces this output?

Which block produces this output?

for loops and range

• for LOOPVAR in range(N): assigns the loop variable a new value each pass, then runs the body. range(N) is exclusive of N.
• range(start, end) and range(start, end, step) control where the loop begins, ends, and how far it jumps each pass.
• A running total (or product) needs a starting value that's a no-op for its operation: 0 for addition, 1 for multiplication.
• To loop backwards from y down to x inclusively, use range(y, x-1, -1).

A loop inside a loop

Just like an if can nest inside another if, a for loop can nest inside another for loop. The two loop variables update at very different rates, and seeing exactly how is the whole point of this section.

Two loop variables, two speeds

This is why nested loops are so useful for grids, tables, and anything with rows and columns: the outer variable tracks the row, the inner variable sweeps across every column before the row advances.

Which nesting produces this output?

Why does x = 0 contribute no rows?

With y looping over range(x) instead of range(x+1), the very first outer pass (x is 0) contributes zero rows to the output. What's the real reason?

• A Python skips the inner loop entirely whenever the outer variable is 0.
• B range(0) is a valid range with zero values in it, so the inner loop simply runs zero passes.
• C The print statement is unreachable when x is 0.
• D range(0) raises an error that Python silently ignores.

Nested for loops

• The inner loop runs to completion for every single pass of the outer loop, so the inner variable updates far more often.
• The inner loop's range can depend on the outer loop variable, letting each outer pass produce a differently sized inner loop.
• An empty range, like range(0), simply produces zero passes. Nothing crashes, nothing runs.

Looping until something changes

Sometimes you don't know how many passes you'll need before you start. A while loop keeps running so long as a condition is True, re-checking it before every pass, closer to how an if statement behaves than a for loop does.

Guessing a secret number

A program needs to keep asking the user to guess a secret number until they finally guess correctly. Which loop is the right tool, and why?

• A A for loop, since you always know range(10) will work for guessing games.
• B A while loop, since the number of guesses needed can't be known before the program runs.
• C A for loop, since guessing is a kind of counting.
• D It doesn't matter, both loop types handle this equally well.

Try it with your own numbers

Run it and enter whatever numbers you like. Try entering a float. Try entering a negative number. Try entering text that isn't a number at all, and see what happens.

while loops

• A while TEST: loop keeps running as long as TEST is True, re-checking before every pass.
• Use it when you don't know the number of passes in advance, most often because the loop depends on user input.
• Forgetting to update whatever the test depends on is the classic while-loop bug: it produces an infinite loop.

Changing course mid-loop

break and continue both alter a loop's normal flow from inside the body. Used well, they can be very handy. Used too often, they make code harder to follow, so use them sparingly.

Inputs: 5, 10, 15, then 20

total = 0
while True:
    nextNumber = int(input('Enter next: '))
    if nextNumber == 20:
        break
    total += nextNumber
print(total)

If the user enters 5, 10, 15, then 20, what does this print?

• A It doesn't print anything
• B 0
• C 30
• D 50

What if we used break instead?

In the previous example, what happens if you use break instead of continue?

• A The code runs and prints only even numbers.
• B The code crashes.
• C Something else.
• D The code runs but prints nothing.
• E The code runs unchanged, printing only odd numbers.
• F The code runs and prints both even and odd numbers.

Two clearer rewrites

The continue version above shows how it works, but it's not the clearest way to write this. Only reach for continue when it genuinely makes code easier to read, which is rare.

for i in range(12):
    if i % 2 == 1:
        print(i)

for i in range(1, 12, 2):
    print(i)

Stop once the total passes 50

Write a program that adds up numbers the user enters, one at a time, stopping as soon as the running total goes over 50. Then print how many numbers it took. This could be written with a while loop, or with a for loop and a break. Pick whichever feels like the right tool, you'll need to defend your choice next.

break and continue

• break exits the entire loop immediately, often paired with while True: to build a loop that stops from the inside.
• continue skips only the rest of the current pass and jumps back to the top of the loop for the next one.
• Both are optional. A well-chosen loop condition, or a step in range, often reads more clearly than either one.

2.1–2.2, all together

• for LOOPVAR in range(...): for a known number of passes
• while TEST: for an unknown number, re-checked every pass.
• Nested loops run the inner loop to completion on every single pass of the outer loop. The inner variable updates far more often than the outer one.
• break exits a loop entirely. continue skips only the current pass. Both are optional, and both are easy to overuse.

Write isPrime(n)

Write the function isPrime(n) that takes a possibly-negative integer n and returns True if n is prime, and False otherwise.

The starter code on the next slide includes a set of tests. A loop is the natural tool for checking whether any smaller number divides evenly into n.

Make every assert pass

Write nthPrime(n)

Write the function nthPrime(n) that takes a non-negative integer n and returns the nth prime number. 2 is the 0th prime number, 3 is the 1st prime number, and so on.

Make every assert pass

Write reverseNumber(n)

Write the function reverseNumber(n) that takes an integer n and returns an integer with its digits in the reverse order of the digits in n.

Make every assert pass

Write mostFrequentDigit(n)

Write the function mostFrequentDigit(n) that takes a possibly-negative integer n and returns the digit from 0 to 9 that occurs most frequently in n. Ties go to the larger digit.

Make every assert pass

Replace the placeholder return 42 with real logic, then run main(). Silence means every assert in testMostFrequentDigit passed; an AssertionError tells you exactly which case still fails.

Write hasConsecutiveDigits(n)

Write the function hasConsecutiveDigits(n) that takes a possibly-negative integer n and returns True if that number contains two consecutive digits that are the same, and False otherwise.

For example, 1223 has two consecutive 2's, but 1232 does not. A loop that compares each digit to the one right before it will catch this.

Make every assert pass

Replace the placeholder return 42 with real logic, then run main(). Silence means every assert in testHasConsecutiveDigits passed; an AssertionError tells you exactly which case still fails.